//package com.wx.tools;
//
//public class WxPayUtils {
//	
//	
//		//微信商户的id
//		public static final String MCH_ID = "1480911042";
//		//微信商户的key  签名使用
//		public static final String KEY="1bKk1wpnRbT2seZKOM2GEWoSJSoL1SRF";
//		public static final String  CHARSET = "UTF-8";//编码格式
//		//证书url
//		public static final String CA_LICENSE =  "E:" + File.separator + "pay"
//		+ File.separator + "cert" + File.separator + "apiclient_cert.p12";
//
//		 
//
////		  3.获取商户号的公钥
////		  调用的接口:https://fraud.mch.weixin.qq.com/risk/getpublickey
////		  请求参数:	mch_id,nonce_str(长度小于32位的随机字符串),sign(签名),sign_type(签名类型:MD5)
////		  请求方式:post
//		  
//		  public class GetPublicKey {
//		public String getPublicKey() throws Exception {
//		SortedMap<Object, Object> parameters = new TreeMap<Object, Object>();
//		String nonce_str = StringUtils1.getStrRandom(28);//获取随机字符串
//		parameters.put("mch_id", WChatInfo.MCH_ID);
//		parameters.put("nonce_str", nonce_str);
//		parameters.put("sign_type", "MD5");
//		// 创建签名
//		String sign = SignUtils.creatSign(WChatInfo.CHARSET, parameters);
//		System.out.println(sign);
//
//
//		TreeMap<String, String> tmap = new TreeMap<String, String>();
//		tmap.put("mch_id", WChatInfo.MCH_ID);
//		tmap.put("nonce_str", nonce_str);
//		tmap.put("sign_type", "MD5");
//		tmap.put("sign", sign);
//		String xml = XMLUtils.getRequestXml(tmap);//将请求参数转换为请求报文
//		        //带证书请求
//		String xml1 = HttpClientCustomSSL.httpClientResultGetPublicKey(xml);//发送http的post请求获取公钥报文
//		String publicKey = XMLUtils.Progress_resultParseXml(xml1);//解析腾迅返回的公钥xml并获取公钥元素
//		return publicKey;
//
//
//		}
//		}
//		/**
//		 *获取随机字符串
//		 **/
//		public class StringUtils1 {
//		/**
//		* 获取随机字符串
//		* @param length 生成的随机字符串长度
//		* */
//		public static String getStrRandom(int length){
//		if(length<1){
//		return "";
//		}else{
//		String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz";
//		StringBuilder sb = new StringBuilder();
//		Random ra = new Random();
//		int index = 0;
//		for (int i = 0; i < length ;i++ ) {
//		index = ra.nextInt(str.length());
//		sb.append(str.charAt(index));
//		}
//		return sb.toString();
//		}
//		}
//		}
//		/**
//		 *创建签名
//		 **/
//		public class SignUtils {
//
//
//		/**
//		* @param characterEncoding 编码格式 utf-8
//		* */
//		public static String creatSign(String characterEncoding,
//		SortedMap<Object, Object> parameters) {
//		StringBuffer sb = new StringBuffer();
//		Set es = parameters.entrySet();
//		Iterator it = es.iterator();
//		while(it.hasNext()) {
//		Map.Entry entry = (Map.Entry)it.next();
//		String k = (String)entry.getKey();
//		Object v = entry.getValue();
//		if(null != v && !"".equals(v) 
//		&& !"sign".equals(k) && !"key".equals(k)) {
//		sb.append(k + "=" + v + "&");
//		}
//		}
//		sb.append("key=" + WChatInfo.KEY);
//		String sign = MD5Utils.MD5Encode(sb.toString(), characterEncoding).toUpperCase();
//		System.out.println(sign);
//		return sign;
//		}
//		}
//		/**
//		 *MD5加密
//		 **/
//		public class MD5Utils {
//
//
//		private static String byteArrayToHexString(byte b[]) {
//		StringBuffer resultSb = new StringBuffer();
//		for (int i = 0; i < b.length; i++)
//		resultSb.append(byteToHexString(b[i]));
//
//
//		return resultSb.toString();
//		}
//
//
//		private static String byteToHexString(byte b) {
//		int n = b;
//		if (n < 0)
//		n += 256;
//		int d1 = n / 16;
//		int d2 = n % 16;
//		return hexDigits[d1] + hexDigits[d2];
//		}
//
//
//		public static String MD5Encode(String origin, String charsetname) {
//		String resultString = null;
//		try {
//		resultString = new String(origin);
//		MessageDigest md = MessageDigest.getInstance("MD5");
//		if (charsetname == null || "".equals(charsetname))
//		resultString = byteArrayToHexString(md.digest(resultString
//		.getBytes()));
//		else
//		resultString = byteArrayToHexString(md.digest(resultString
//		.getBytes(charsetname)));
//		} catch (Exception exception) {
//		}
//		return resultString;
//		}
//
//
//		private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
//		"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
//
//
//		}
//
//
//		/**
//		 *将请求参数转换为请求报文和解析腾迅返回的公钥xml并获取公钥元素
//		 **/
//		public class XMLUtils {
//		/**
//		* 将请求参数转换为请求报文
//		*/
//		@SuppressWarnings("rawtypes")
//		public static String getRequestXml(TreeMap<String, String> parameters)
//		throws Exception {
//		StringBuffer sb = new StringBuffer();
//		sb.append("<xml>");
//		Set es = parameters.entrySet();
//		Iterator it = es.iterator();
//		while (it.hasNext()) {
//		Map.Entry entry = (Map.Entry) it.next();
//		String k = (String) entry.getKey();
//		String v = (String) entry.getValue();
//		if ("mch_id".equalsIgnoreCase(k) || "nonce_str".equalsIgnoreCase(k)
//		|| "sign".equalsIgnoreCase(k)) {
//		sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");
//		} else {
//		sb.append("<" + k + ">" + v + "</" + k + ">");
//		}
//		}
//		sb.append("</xml>");
//		return sb.toString();
//		}
//		/**
//		* 解析腾迅返回的公钥xml并获取公钥元素
//		* @param xml
//		* @return
//		*/
//		@SuppressWarnings("unchecked")
//		public static String Progress_resultParseXml(String xml) {
//		String publicKey = null;
//		try {
//		StringReader read = new StringReader(xml);
//
//		InputSource source = new InputSource(read);
//
//		SAXBuilder sb = new SAXBuilder();
//
//		org.jdom.Document doc;
//		doc = (org.jdom.Document) sb.build(source);
//
//
//		org.jdom.Element root = doc.getRootElement();
//		List<org.jdom.Element> list = root.getChildren();
//
//		if (list != null && list.size() > 0) {
//		for (org.jdom.Element element : list) {
//		if("pub_key".equals(element.getName())){
//		publicKey=element.getText();
//		}
//		}
//		}
//
//
//		} catch (IOException e) {
//		e.printStackTrace();
//		} catch (Exception e) {
//		e.printStackTrace();
//		}
//		return publicKey;
//		}
//		}
//		/**
//		 * 发送公钥的http请求以及企业支付到银行卡的http请求
//		 * 
//		 * */
//		public class HttpClientCustomSSL {
//		/**
//		* httpClient 请求获取公钥
//		* @param parms
//		* @return  
//		* @throws Exception
//		*/
//		public static String httpClientResultGetPublicKey(String xml) throws Exception{
//		StringBuffer reultBuffer = new StringBuffer();
//
//
//		SSLConnectionSocketFactory sslsf = ReadSSl.getInstance().readCustomSSL();
//
//
//		HttpPost httpPost = new HttpPost("https://fraud.mch.weixin.qq.com/risk/getpublickey");
//		        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
//		        StringEntity myEntity = new org.apache.http.entity.StringEntity(xml,WChatInfo.CHARSET);
//		        myEntity.setContentType("text/xml;charset=UTF-8");
//		        myEntity.setContentEncoding(WChatInfo.CHARSET);
//		        httpPost.setHeader("Content-Type", "text/xml; charset=UTF-8");
//		        httpPost.setEntity(myEntity);
//		        
//		        CloseableHttpResponse response      = null;
//		        InputStream inputStream	        = null;
//		        InputStreamReader inputStreamReader = null;
//		        BufferedReader bufferedReader       = null;
//		        try {
//		        response = httpclient.execute(httpPost);
//		        HttpEntity entity = response.getEntity();
//		if (entity!=null){
//		inputStream = entity.getContent();
//		inputStreamReader = new InputStreamReader(inputStream,WChatInfo.CHARSET);
//		bufferedReader = new BufferedReader(inputStreamReader);
//		String str = null;
//		while ((str = bufferedReader.readLine()) != null) {
//		reultBuffer.append(str);
//		}
//		}
//		} catch (ClientProtocolException e) {
//		e.printStackTrace();
//		} catch (IOException e) {
//		e.printStackTrace();
//		}finally{
//
//
//		httpclient.close();
//		response.close();
//		bufferedReader.close();
//		inputStreamReader.close();
//		inputStream.close();
//		inputStream = null;
//		}
//		     
//		        return reultBuffer.toString();
//		}
//		/**
//		* httpClient 请求企业支付到银行卡
//		* @param parms
//		* @return  
//		* @throws Exception
//		*/
//		public static String httpClientResultPANK(String xml) throws Exception{
//		StringBuffer reultBuffer = new StringBuffer();
//
//
//		SSLConnectionSocketFactory sslsf = ReadSSl.getInstance().readCustomSSL();
//
//
//		HttpPost httpPost = new HttpPost("https://api.mch.weixin.qq.com/mmpaysptrans/pay_bank");
//		        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
//		        StringEntity myEntity = new org.apache.http.entity.StringEntity(xml, WChatInfo.CHARSET);
//		        myEntity.setContentType("text/xml;charset=UTF-8");
//		        myEntity.setContentEncoding(WChatInfo.CHARSET);
//		        httpPost.setHeader("Content-Type", "text/xml; charset=UTF-8");
//		        httpPost.setEntity(myEntity);
//		        
//		        CloseableHttpResponse response      = null;
//		        InputStream inputStream	        = null;
//		        InputStreamReader inputStreamReader = null;
//		        BufferedReader bufferedReader       = null;
//		        try {
//		        response = httpclient.execute(httpPost);
//		        HttpEntity entity = response.getEntity();
//		if (entity!=null){
//		inputStream = entity.getContent();
//		inputStreamReader = new InputStreamReader(inputStream, WChatInfo.CHARSET);
//		bufferedReader = new BufferedReader(inputStreamReader);
//		String str = null;
//		while ((str = bufferedReader.readLine()) != null) {
//		reultBuffer.append(str);
//		}
//		}
//		} catch (ClientProtocolException e) {
//		e.printStackTrace();
//		} catch (IOException e) {
//		e.printStackTrace();
//		}finally{
//
//
//		httpclient.close();
//		response.close();
//		bufferedReader.close();
//		inputStreamReader.close();
//		inputStream.close();
//		inputStream = null;
//		}
//		    
//		        return reultBuffer.toString();
//		}
//
//		}
//
//
//		/**
//		 * 读取证书
//		 * 
//		 *
//		 */
//		@SuppressWarnings("deprecation")
//		public class ReadSSl {
//		private static ReadSSl readSSL = null;
//
//		private ReadSSl(){
//
//		}
//
//		public static ReadSSl getInstance(){
//		if(readSSL == null){
//		readSSL = new ReadSSl();
//		}
//		return readSSL;
//		}
//		/**
//		*  读取 apiclient_cert.p12 证书
//		* @return
//		* @throws Exception
//		*/
//		public  SSLConnectionSocketFactory readCustomSSL() throws Exception{
//		    KeyStore keyStore  = KeyStore.getInstance("PKCS12");
//		        FileInputStream instream = new FileInputStream(new File(WChatInfo.CA_LICENSE));
//		        try {
//		            keyStore.load(instream, WChatInfo.MCH_ID.toCharArray());
//		        } finally {
//		            instream.close();
//		        }
//		        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, WChatInfo.MCH_ID.toCharArray()).build();
//		        
//		        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory( sslcontext, new String[] { "TLSv1" }, null,
//		                SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
//		        return sslsf;
//		}
//
//
//		}
//
//
//		public class RSAEncrypt {  
//		 
//		    private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',  
//		            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };  
//		  
//
//
//		 
//		    public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)  
//		            throws Exception {  
//		        try {  
//		            byte[] buffer = Base64.decode(publicKeyStr);  
//		            KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
//		            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
//		            return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
//		        } catch (NoSuchAlgorithmException e) {  
//		            throw new Exception("出错了");  
//		        } catch (InvalidKeySpecException e) {  
//		            throw new Exception("出错了");  
//		        } catch (NullPointerException e) {  
//		            throw new Exception("出错了");  
//		        }  
//		    }  
//		  
//
//
//
//
//		  
//		    /** 
//		     * 
//		     *  
//		     * @param publicKey 
//		     *           
//		     * @param plainTextData 
//		     *          
//		     * @return 
//		     * @throws Exception 
//		     *            
//		     */  
//		    public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)  
//		            throws Exception {  
//		        if (publicKey == null) {  
//		            throw new Exception("");  
//		        }  
//		        Cipher cipher = null;  
//		        try {  
//		           
//		            cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA1AndMGF1Padding");  
//		           
//		            cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
//		            byte[] output = cipher.doFinal(plainTextData);  
//		            return output;  
//		        } catch (NoSuchAlgorithmException e) {  
//		            throw new Exception("出错了");  
//		        } catch (NoSuchPaddingException e) {  
//		            e.printStackTrace();  
//		            return null;  
//		        } catch (InvalidKeyException e) {  
//		            throw new Exception("出错了");  
//		        } catch (IllegalBlockSizeException e) {  
//		            throw new Exception("出错了");  
//		        } catch (BadPaddingException e) {  
//		            throw new Exception("出错了");  
//		        }  
//		    }  
//		  
//		   
//		} 
//
//
//		 4.获取的公钥需要转化后才能使用
//		 注明:因为上述获取的公钥是PKCS#1格式的,java可以直接使用的是PKCS#8格式的公钥,所以需要将PKCS#1格式的公钥转换为PKCS#8格式的公钥
//		 PKCS#1 转 PKCS#8
//		 linux下的转换命令:
//		 openssl rsa -RSAPublicKey_in -in <filename> -pubout
//		 注意:将转换后的公钥保存起来,因为后面需要用来加密收款方银行卡号和收款方用户名
//		 如:在.properties的文件中配置:publicKey="bhfuruynvoiudnfxnjwpqfnnfnfnjiy46488578937583892u4bbuffbf"
//		 
//		 
//		 5.企业支付到银行卡的http请求
//		   请求接口:https://api.mch.weixin.qq.com/mmpaysptrans/pay_bank
//		   请求方式:post
//		   请求参数:mch_id,partner_trade_no(商户订单号，需保持唯一（只允许数字[0~9]或字母[A~Z]和[a~z]，最短8位，最长32位）,如:时间戳拼上几位随机数,保证唯一即可),
//		            nonce_str(随机字符串，不长于32位),sign(签名),enc_bank_no(收款方银行卡号,是配合公钥加密后的卡号),enc_true_name(收款方用户名,是配合公钥加密后的用户名)
//		bank_code(收款方开户行,就是具体银行对应的编号,具体在:https://pay.weixin.qq.com/wiki/doc/api/tools/mch_pay.php?chapter=24_4),
//		amount(付款金额(不含手续费的金额),单位为分),desc(付款说明,这个可传可不传)
//
//
//		public class TestWChatToBank {
//
//
//		/**
//		*测试企业支付到银行卡功能
//		* @param args
//		* @throws Exception 
//		*/
//		public static void main(String[] args) throws Exception {
//		// TODO Auto-generated method stub
//		String source ="李四";//银行卡开户名
//		String pank = "6220002340018125678";//银行卡号
//		//注意 这里的  publicKeyPKCS8  是上一步获取微信支付公钥后经openssl 转化成PKCS8格式的公钥
//		String publicKeyPKCS8 = "";//转换为PKCS8格式后的公钥
//		//获得RAS加密后的收款方用户名
//		String enc_true_name =GetRSA.getRSA(source,publicKeyPKCS8);//将收款方用户名配合公钥加密
//		//获得RAS加密后的收款方银行卡号
//		String enc_bank_no = GetRSA.getRSA(pank,publicKeyPKCS8);//将收款方银行卡号配合公钥加密
//		    String bank_code = "1003";//开户行对应的编号
//		    String amount = "100";//付款金额,这里是100分
//		    String desc ="测试";//付款说明
//		    String partner_trade_no = "2017112433233331";//商户订单号
//		  
//		    String nonce_str1 =  StringUtils1.getStrRandom(28);//获得随机字符串
//		    
//		    //获取签名
//		    SortedMap<Object,Object> parameters1 = new TreeMap<Object,Object>();
//		parameters1.put("mch_id", WChatInfo.MCH_ID);
//		parameters1.put("partner_trade_no", partner_trade_no);
//		parameters1.put("nonce_str", nonce_str1);
//		parameters1.put("enc_bank_no", enc_bank_no);
//		parameters1.put("enc_true_name", enc_true_name);
//		parameters1.put("bank_code", bank_code);
//		parameters1.put("amount", amount);
//		parameters1.put("desc", desc);
//		String sign1 = SignUtils.creatSign(WChatInfo.CHARSET, parameters1);
//		//请求企业付款
//		TreeMap<String, String> tmap1 = new TreeMap<String, String>();
//		tmap1.put("mch_id", WChatInfo.MCH_ID);
//		tmap1.put("partner_trade_no", partner_trade_no);
//		tmap1.put("nonce_str", nonce_str1);
//		tmap1.put("enc_bank_no", enc_bank_no);
//		tmap1.put("enc_true_name", enc_true_name);
//		tmap1.put("bank_code", bank_code);
//		tmap1.put("amount", amount);
//		tmap1.put("desc", desc);
//		tmap1.put("sign", sign1);
//		String xml2 = XMLUtils.getRequestXml(tmap1);//将请求参数转换为请求报文
//
//		String  xml3= HttpClientCustomSSL.httpClientResultPANK(xml2);//发送请求
//		System.out.println(xml3);
//
//
//		}
//
//		}
//
//
//		/**
//		 * rsa加密
//		 * 
//		 * */
//		public class GetRSA {  
//		 /**
//		  * @param publicKeyPKCS8  为pkcs8格式的公钥
//		  * */
//		   public static String getRSA(String str,String publicKeyPKCS8) throws Exception {  
//		       byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(publicKeyPKCS8),str.getBytes());  
//		       String cipher=Base64.encode(cipherData);  
//		       return cipher;
//		         
//		   }  
//		}  
//
//
//		public class RSAEncrypt {  
//		 
//		    private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',  
//		            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };  
//		  
//
//
//		 
//		    public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)  
//		            throws Exception {  
//		        try {  
//		            byte[] buffer = Base64.decode(publicKeyStr);  
//		            KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
//		            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
//		            return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
//		        } catch (NoSuchAlgorithmException e) {  
//		            throw new Exception("出错了");  
//		        } catch (InvalidKeySpecException e) {  
//		            throw new Exception("出错了");  
//		        } catch (NullPointerException e) {  
//		            throw new Exception("出错了");  
//		        }  
//		    }  
//		  
//		    /** 
//		     * 
//		     *  
//		     * @param publicKey 
//		     *           
//		     * @param plainTextData 
//		     *          
//		     * @return 
//		     * @throws Exception 
//		     *            
//		     */  
//		    public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)  
//		            throws Exception {  
//		        if (publicKey == null) {  
//		            throw new Exception("");  
//		        }  
//		        Cipher cipher = null;  
//		        try {  
//		           
//		            cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA1AndMGF1Padding");  
//		           
//		            cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
//		            byte[] output = cipher.doFinal(plainTextData);  
//		            return output;  
//		        } catch (NoSuchAlgorithmException e) {  
//		            throw new Exception("出错了");  
//		        } catch (NoSuchPaddingException e) {  
//		            e.printStackTrace();  
//		            return null;  
//		        } catch (InvalidKeyException e) {  
//		            throw new Exception("出错了");  
//		        } catch (IllegalBlockSizeException e) {  
//		            throw new Exception("出错了");  
//		        } catch (BadPaddingException e) {  
//		            throw new Exception("出错了");  
//		        }  
//		    }  
//		  
//		   
//		} 
//
//
//		public final class Base64 {  
//		  
//		    static private final int     BASELENGTH           = 128;  
//		    static private final int     LOOKUPLENGTH         = 64;  
//		    static private final int     TWENTYFOURBITGROUP   = 24;  
//		    static private final int     EIGHTBIT             = 8;  
//		    static private final int     SIXTEENBIT           = 16;  
//		    static private final int     FOURBYTE             = 4;  
//		    static private final int     SIGN                 = -128;  
//		    static private final char    PAD                  = '=';  
//		    static private final boolean fDebug               = false;  
//		    static final private byte[]  base64Alphabet       = new byte[BASELENGTH];  
//		    static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];  
//		  
//		    static {  
//		        for (int i = 0; i < BASELENGTH; ++i) {  
//		            base64Alphabet[i] = -1;  
//		        }  
//		        for (int i = 'Z'; i >= 'A'; i--) {  
//		            base64Alphabet[i] = (byte) (i - 'A');  
//		        }  
//		        for (int i = 'z'; i >= 'a'; i--) {  
//		            base64Alphabet[i] = (byte) (i - 'a' + 26);  
//		        }  
//		  
//		        for (int i = '9'; i >= '0'; i--) {  
//		            base64Alphabet[i] = (byte) (i - '0' + 52);  
//		        }  
//		  
//		        base64Alphabet['+'] = 62;  
//		        base64Alphabet['/'] = 63;  
//		  
//		        for (int i = 0; i <= 25; i++) {  
//		            lookUpBase64Alphabet[i] = (char) ('A' + i);  
//		        }  
//		  
//		        for (int i = 26, j = 0; i <= 51; i++, j++) {  
//		            lookUpBase64Alphabet[i] = (char) ('a' + j);  
//		        }  
//		  
//		        for (int i = 52, j = 0; i <= 61; i++, j++) {  
//		            lookUpBase64Alphabet[i] = (char) ('0' + j);  
//		        }  
//		        lookUpBase64Alphabet[62] = (char) '+';  
//		        lookUpBase64Alphabet[63] = (char) '/';  
//		  
//		    }  
//		  
//		    private static boolean isWhiteSpace(char octect) {  
//		        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);  
//		    }  
//		  
//		    private static boolean isPad(char octect) {  
//		        return (octect == PAD);  
//		    }  
//		  
//		    private static boolean isData(char octect) {  
//		        return (octect < BASELENGTH && base64Alphabet[octect] != -1);  
//		    }  
//		  
//		    /** 
//		     * Encodes hex octects into Base64 
//		     * 
//		     * @param binaryData Array containing binaryData 
//		     * @return Encoded Base64 array 
//		     */  
//		    public static String encode(byte[] binaryData) {  
//		  
//		        if (binaryData == null) {  
//		            return null;  
//		        }  
//		  
//		        int lengthDataBits = binaryData.length * EIGHTBIT;  
//		        if (lengthDataBits == 0) {  
//		            return "";  
//		        }  
//		  
//		        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;  
//		        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;  
//		        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;  
//		        char encodedData[] = null;  
//		  
//		        encodedData = new char[numberQuartet * 4];  
//		  
//		        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;  
//		  
//		        int encodedIndex = 0;  
//		        int dataIndex = 0;  
//		        if (fDebug) {  
//		            System.out.println("number of triplets = " + numberTriplets);  
//		        }  
//		  
//		        for (int i = 0; i < numberTriplets; i++) {  
//		            b1 = binaryData[dataIndex++];  
//		            b2 = binaryData[dataIndex++];  
//		            b3 = binaryData[dataIndex++];  
//		  
//		            if (fDebug) {  
//		                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);  
//		            }  
//		  
//		            l = (byte) (b2 & 0x0f);  
//		            k = (byte) (b1 & 0x03);  
//		  
//		            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
//		            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);  
//		            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);  
//		  
//		            if (fDebug) {  
//		                System.out.println("val2 = " + val2);  
//		                System.out.println("k4   = " + (k << 4));  
//		                System.out.println("vak  = " + (val2 | (k << 4)));  
//		            }  
//		  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];  
//		        }  
//		  
//		        // form integral number of 6-bit groups  
//		        if (fewerThan24bits == EIGHTBIT) {  
//		            b1 = binaryData[dataIndex];  
//		            k = (byte) (b1 & 0x03);  
//		            if (fDebug) {  
//		                System.out.println("b1=" + b1);  
//		                System.out.println("b1<<2 = " + (b1 >> 2));  
//		            }  
//		            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];  
//		            encodedData[encodedIndex++] = PAD;  
//		            encodedData[encodedIndex++] = PAD;  
//		        } else if (fewerThan24bits == SIXTEENBIT) {  
//		            b1 = binaryData[dataIndex];  
//		            b2 = binaryData[dataIndex + 1];  
//		            l = (byte) (b2 & 0x0f);  
//		            k = (byte) (b1 & 0x03);  
//		  
//		            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
//		            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);  
//		  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];  
//		            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];  
//		            encodedData[encodedIndex++] = PAD;  
//		        }  
//		  
//		        return new String(encodedData);  
//		    }  
//		  
//		    /** 
//		     * Decodes Base64 data into octects 
//		     * 
//		     * @param encoded string containing Base64 data 
//		     * @return Array containind decoded data. 
//		     */  
//		    public static byte[] decode(String encoded) {  
//		  
//		        if (encoded == null) {  
//		            return null;  
//		        }  
//		  
//		        char[] base64Data = encoded.toCharArray();  
//		        // remove white spaces  
//		        int len = removeWhiteSpace(base64Data);  
//		  
//		        if (len % FOURBYTE != 0) {  
//		            return null;//should be divisible by four  
//		        }  
//		  
//		        int numberQuadruple = (len / FOURBYTE);  
//		  
//		        if (numberQuadruple == 0) {  
//		            return new byte[0];  
//		        }  
//		  
//		        byte decodedData[] = null;  
//		        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;  
//		        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;  
//		  
//		        int i = 0;  
//		        int encodedIndex = 0;  
//		        int dataIndex = 0;  
//		        decodedData = new byte[(numberQuadruple) * 3];  
//		  
//		        for (; i < numberQuadruple - 1; i++) {  
//		  
//		            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))  
//		                || !isData((d3 = base64Data[dataIndex++]))  
//		                || !isData((d4 = base64Data[dataIndex++]))) {  
//		                return null;  
//		            }//if found "no data" just return null  
//		  
//		            b1 = base64Alphabet[d1];  
//		            b2 = base64Alphabet[d2];  
//		            b3 = base64Alphabet[d3];  
//		            b4 = base64Alphabet[d4];  
//		  
//		            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);  
//		            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
//		            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);  
//		        }  
//		  
//		        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {  
//		            return null;//if found "no data" just return null  
//		        }  
//		  
//		        b1 = base64Alphabet[d1];  
//		        b2 = base64Alphabet[d2];  
//		  
//		        d3 = base64Data[dataIndex++];  
//		        d4 = base64Data[dataIndex++];  
//		        if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters  
//		            if (isPad(d3) && isPad(d4)) {  
//		                if ((b2 & 0xf) != 0)//last 4 bits should be zero  
//		                {  
//		                    return null;  
//		                }  
//		                byte[] tmp = new byte[i * 3 + 1];  
//		                System.arraycopy(decodedData, 0, tmp, 0, i * 3);  
//		                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);  
//		                return tmp;  
//		            } else if (!isPad(d3) && isPad(d4)) {  
//		                b3 = base64Alphabet[d3];  
//		                if ((b3 & 0x3) != 0)//last 2 bits should be zero  
//		                {  
//		                    return null;  
//		                }  
//		                byte[] tmp = new byte[i * 3 + 2];  
//		                System.arraycopy(decodedData, 0, tmp, 0, i * 3);  
//		                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);  
//		                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
//		                return tmp;  
//		            } else {  
//		                return null;  
//		            }  
//		        } else { //No PAD e.g 3cQl  
//		            b3 = base64Alphabet[d3];  
//		            b4 = base64Alphabet[d4];  
//		            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);  
//		            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
//		            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);  
//		  
//		        }  
//		  
//		        return decodedData;  
//		    }  
//		  
//		    /** 
//		     * remove WhiteSpace from MIME containing encoded Base64 data. 
//		     * 
//		     * @param data  the byte array of base64 data (with WS) 
//		     * @return      the new length 
//		     */  
//		    private static int removeWhiteSpace(char[] data) {  
//		        if (data == null) {  
//		            return 0;  
//		        }  
//		  
//		        // count characters that's not whitespace  
//		        int newSize = 0;  
//		        int len = data.length;  
//		        for (int i = 0; i < len; i++) {  
//		            if (!isWhiteSpace(data[i])) {  
//		                data[newSize++] = data[i];  
//		            }  
//		        }  
//		        return newSize;  
//		    }  
//		}  
//
//
//}
